/*

 * To change this template, choose Tools | Templates

 * and open the template in the editor.

 */
package Interface;

import java.util.LinkedList;

import java.util.List;

import javax.swing.table.AbstractTableModel;

import negocio.Coluna;

/**
 *
 *
 *
 * @author asouza
 *
 */
public class ModelTable extends AbstractTableModel {

    //Lista de Produtos Novos que representará as linhas
    private List<Coluna> linhas;
    //Array que contém os nomes das colunas do seu modelo
    private String[] colunas = new String[]{
        "Coluna", "Tipo", "Tamanho", "Precisao", "Nulo", "Tam Médio",
        "Perc. Nulo"};

    //Cria um ProdutosNovosTableModel vazio
    public ModelTable() {
        linhas = new LinkedList<>();
    }

    //Cria um ProdutosNovosTableModel ja populado, recebendo uma lista de produtos
    public ModelTable(List<Coluna> listaDeProdutos) {
        linhas = new LinkedList<>(listaDeProdutos);
    }

    //Retorna a quantidade de colunas do modelo, que no caso será fixa
    @Override
    public int getColumnCount() {
        return colunas.length;
    }

    //Retorna a quantidade de linhas atual do objeto, que no caso é o tamnho da lista
    @Override
    public int getRowCount() {
        return linhas.size();
    }

    //Retorna o nome da coluna, recebendo seu índice
    @Override
    public String getColumnName(int indiceColuna) {
        return colunas[indiceColuna];
    }

    //Retorna o tipo dos dados com que a coluna especificada trabalha, no caso, a Classe
    @Override
    public Class<?> getColumnClass(int indiceColuna) {
    switch (indiceColuna) {
        case 0:
                return String.class;
            case 1:
                return String.class;
            case 2:
                return Integer.class;
            case 3:
                return Integer.class;
            case 4:
                return String.class;
            case 5:
                return Float.class;
            case 6:
                return Float.class;
            default:
                //Se a coluna especificada não existir é lançada uma exceção
                throw new IndexOutOfBoundsException("A coluna com o índice:" + indiceColuna + " não existe!");
        }
    }

    //Retorna o valor da cécula definida pelos índices de linha+coluna
    @Override
    public Object getValueAt(int indiceLinha, int indiceColuna) {
        //Verifica o índice da linha e obtém o valor através da posição na lista
        Coluna produtoNovo = linhas.get(indiceLinha);
        //Verifica o índice da coluna e obtém o valor
        switch (indiceColuna) {
            case 0:
                return produtoNovo.getColuna();
            case 1:
                return produtoNovo.getTipo();
            case 2:
                return produtoNovo.getTamanho();
            case 3:
                return produtoNovo.getPrecisao();
            case 4:
                return produtoNovo.getNulo();
            case 5:
                return produtoNovo.getTamanhoMedio();
            case 6:
                return produtoNovo.getPercentualNulo();
            default:
                //Se a coluna especificada não existir é lançada uma exceção
                throw new IndexOutOfBoundsException("A coluna com o índice:" + indiceColuna + " não existe!");
        }

    }
     @Override
    public boolean isCellEditable(int rowIndex, int columnIndex) {
         boolean bool = false;
         if(columnIndex == 5 || columnIndex == 6) bool = true;
         return bool;
    }

    //Recebe o Object que será o valor a ser alterado, e a posição linha+coluna, onde mostra
    //exatamente qual célula da tabela será alterada
    public void setValueAt(Object valor, int indiceLinha, int indiceColuna) {
        //Obtém o objeto em questão, para alteração, de acordo com o índice de linha recebido
        Coluna produtoNovo = linhas.get(indiceLinha);
        
          if (indiceColuna == 0)
                produtoNovo.setColuna((String) valor);
          else if(indiceColuna == 1)   
                produtoNovo.setTipo((String) valor);    
          else if(indiceColuna == 2)   
                produtoNovo.setTamanho((int) valor);
          else if(indiceColuna == 3)   
                produtoNovo.setPrecisao((int) valor);
          else if(indiceColuna == 4)   
                produtoNovo.setNulo((String) valor);
          else if(indiceColuna == 5)   
                produtoNovo.setTamanhoMedio((float) valor);
          else if(indiceColuna == 6)   
                produtoNovo.setPercentualNulo((float) valor);
        
        fireTableCellUpdated(indiceLinha, indiceColuna); // Notifica a atualização da célula        
    }
       

    //Retorna um objeto do tipo ProdutoNovo, de acordo com o índice especificado
    public Coluna getProduto(int indiceLinha){
        return linhas.get(indiceLinha);
    }

    //Adiciona uma linha, recebendo um Objeto do tipo ProdutoNovo
    public void addProduto(Coluna produtoNovo) {
        linhas.add(produtoNovo);
        //Pega a quantidade de linhas e subtrai um para achar o último índice.
        //É preciso subtrair um pois os índices começam pelo zero.
        int ultimoIndice = getRowCount() - 1;
        //Aqui reportamos a mudança para o JTable, assim ele pode se redesenhar, para visualizarmos a alteração
        fireTableRowsInserted(ultimoIndice, ultimoIndice);
    }

    //Remove a linha especificada
    public void removeProduto(int indiceLinha) {
        linhas.remove(indiceLinha);
        //Aqui reportamos a mudança para o JTable, assim ele pode se redesenhar, para visualizarmos a alteração
        fireTableRowsDeleted(indiceLinha, indiceLinha);
    }

    //Adicionamos várias linhas na tabela de uma vez, recebendo um List de ProdutoNovo
    public void addListaDeProdutos(List<Coluna> produtos) {
        int tamanhoAntigo = getRowCount();
        //Adiciona os produtos
        linhas.addAll(produtos);
        //Aqui reportamos a mudança para o JTable, assim ele pode se redesenhar, para visualizarmos a alteração
        fireTableRowsInserted(tamanhoAntigo, getRowCount() - 1);
        //fireTableRowsInserted(tamanhoAntigo, tamanhoAntigo + linhas.size());
    }

    //Remove todas as linhas
    public void limpar() {
        linhas.clear();
        //Aqui reportamos a mudança para o JTable, assim ele pode se redesenhar, para visualizarmos a alteração
        fireTableDataChanged();
    }

    //Verifica se existe linhas
    public boolean isEmpty() {
        return linhas.isEmpty();
    }
}